પાયથોન SQLAlchemy સેશન મેનેજમેન્ટ: ડેટા અખંડિતતા માટે ટ્રાન્ઝેક્શન હેન્ડલિંગમાં નિપુણતા

SQLAlchemy એ એક શક્તિશાળી અને લવચીક પાયથોન લાઇબ્રેરી છે જે ડેટાબેઝ સાથે ક્રિયાપ્રતિક્રિયા કરવા માટે એક વ્યાપક ટૂલકિટ પ્રદાન કરે છે. SQLAlchemy ના કેન્દ્રમાં સેશન ની વિભાવના રહેલી છે, જે તમે તમારા ડેટાબેઝ પર કરો છો તે તમામ કાર્યો માટે એક સ્ટેજિંગ ઝોન તરીકે કાર્ય કરે છે. ડેટા અખંડિતતા જાળવવા અને સુસંગત ડેટાબેઝ વર્તન સુનિશ્ચિત કરવા માટે, ખાસ કરીને સમકાલીન વિનંતીઓનું સંચાલન કરતી જટિલ એપ્લિકેશન્સમાં, યોગ્ય સેશન અને ટ્રાન્ઝેક્શન મેનેજમેન્ટ નિર્ણાયક છે.

SQLAlchemy સેશન્સને સમજવું

એક SQLAlchemy સેશન કાર્યના એક એકમ, ડેટાબેઝ સાથેની વાતચીતનું પ્રતિનિધિત્વ કરે છે. તે ઑબ્જેક્ટ્સમાં કરાયેલા ફેરફારોને ટ્રૅક કરે છે, જે તમને તેમને એક જ અણુ ઓપરેશન તરીકે ડેટાબેઝમાં સાચવવાની મંજૂરી આપે છે. તેને એક વર્કસ્પેસ તરીકે વિચારો જ્યાં તમે ડેટાને સત્તાવાર રીતે સાચવતા પહેલા ફેરફારો કરો છો. સુવ્યવસ્થિત સેશન વિના, તમને ડેટા અસંગતતાઓ અને સંભવિત ભ્રષ્ટાચારનું જોખમ રહેલું છે.

સેશન બનાવવું

તમે તમારા ડેટાબેઝ સાથે ક્રિયાપ્રતિક્રિયા કરવાનું શરૂ કરો તે પહેલાં, તમારે એક સેશન બનાવવાની જરૂર છે. આમાં સૌપ્રથમ SQLAlchemy ના એન્જિનનો ઉપયોગ કરીને ડેટાબેઝ સાથે કનેક્શન સ્થાપિત કરવાનો સમાવેશ થાય છે.

            from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

# Database connection string
db_url = 'sqlite:///:memory:'  # Replace with your database URL (e.g., PostgreSQL, MySQL)

# Create an engine
engine = create_engine(db_url, echo=False) # echo=True to see the generated SQL

# Define a base for declarative models
Base = declarative_base()

# Define a simple model
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String)

    def __repr__(self):
        return f"<User(name='{self.name}', email='{self.email}')>"

# Create the table in the database
Base.metadata.create_all(engine)

# Create a session class
Session = sessionmaker(bind=engine)

# Instantiate a session
session = Session()

            

              
                Copy
              
            
          

આ ઉદાહરણમાં:

• અમે જરૂરી SQLAlchemy મોડ્યુલોને ઇમ્પોર્ટ કરીએ છીએ.
• અમે એક ડેટાબેઝ કનેક્શન સ્ટ્રિંગ (`db_url`) ને વ્યાખ્યાયિત કરીએ છીએ. આ ઉદાહરણ સરળતા માટે ઇન-મેમરી SQLite ડેટાબેઝનો ઉપયોગ કરે છે, પરંતુ તમે તેને તમારા ડેટાબેઝ સિસ્ટમ (દા.ત., PostgreSQL, MySQL) માટે યોગ્ય કનેક્શન સ્ટ્રિંગ સાથે બદલશો. વિશિષ્ટ ફોર્મેટ તમે ઉપયોગ કરી રહ્યા છો તે ડેટાબેઝ એન્જિન અને ડ્રાઇવરના આધારે બદલાય છે. સાચા કનેક્શન સ્ટ્રિંગ ફોર્મેટ માટે SQLAlchemy ડોક્યુમેન્ટેશન અને તમારા ડેટાબેઝ પ્રદાતાના ડોક્યુમેન્ટેશનનો સંપર્ક કરો.
• અમે `create_engine()` નો ઉપયોગ કરીને એક `engine` બનાવીએ છીએ. એન્જિન કનેક્શન પૂલનું સંચાલન કરવા અને ડેટાબેઝ સાથે સંચાર માટે જવાબદાર છે. `echo=True` પેરામીટર ડિબગિંગ માટે મદદરૂપ થઈ શકે છે, કારણ કે તે જનરેટ થયેલ SQL સ્ટેટમેન્ટ્સને કન્સોલ પર પ્રિન્ટ કરશે.
• અમે `declarative_base()` નો ઉપયોગ કરીને એક બેઝ ક્લાસ (`Base`) વ્યાખ્યાયિત કરીએ છીએ. આનો ઉપયોગ આપણા તમામ SQLAlchemy મોડેલ્સ માટે બેઝ ક્લાસ તરીકે થાય છે.
• અમે એક `User` મોડેલ વ્યાખ્યાયિત કરીએ છીએ, તેને `users` નામના ડેટાબેઝ ટેબલ પર મેપ કરીએ છીએ.
• અમે `Base.metadata.create_all(engine)` નો ઉપયોગ કરીને ડેટાબેઝમાં ટેબલ બનાવીએ છીએ.
• અમે `sessionmaker(bind=engine)` નો ઉપયોગ કરીને એક સેશન ક્લાસ બનાવીએ છીએ. આ સેશન ક્લાસને નિર્દિષ્ટ એન્જિનનો ઉપયોગ કરવા માટે ગોઠવે છે.
• છેલ્લે, અમે `Session()` નો ઉપયોગ કરીને એક સેશન ઇન્સ્ટન્ટિએટ કરીએ છીએ.

ટ્રાન્ઝેક્શન્સને સમજવું

એક ટ્રાન્ઝેક્શન એ કાર્યના એક જ તાર્કિક એકમ તરીકે ગણવામાં આવતી ડેટાબેઝ કામગીરીનો ક્રમ છે. ટ્રાન્ઝેક્શન્સ ACID ગુણધર્મોનું પાલન કરે છે:

• એટોમિસિટી (Atomicity): ટ્રાન્ઝેક્શનમાંની તમામ કામગીરીઓ કાં તો સંપૂર્ણપણે સફળ થાય છે અથવા સંપૂર્ણપણે નિષ્ફળ જાય છે. જો ટ્રાન્ઝેક્શનનો કોઈ પણ ભાગ નિષ્ફળ જાય, તો આખું ટ્રાન્ઝેક્શન રોલ બેક થઈ જાય છે.
• સુસંગતતા (Consistency): ટ્રાન્ઝેક્શન ડેટાબેઝને માન્ય સ્થિતિમાં જાળવી રાખવું જોઈએ. તે કોઈપણ ડેટાબેઝ અવરોધો અથવા નિયમોનું ઉલ્લંઘન કરી શકતું નથી.
• આઇસોલેશન (Isolation): સમકાલીન ટ્રાન્ઝેક્શન્સ એકબીજાથી અલગ હોય છે. એક ટ્રાન્ઝેક્શન દ્વારા કરાયેલા ફેરફારો અન્ય ટ્રાન્ઝેક્શન્સને ત્યાં સુધી દેખાતા નથી જ્યાં સુધી પ્રથમ ટ્રાન્ઝેક્શન કમિટ ન થાય.
• ટકાઉપણું (Durability): એકવાર ટ્રાન્ઝેક્શન કમિટ થઈ જાય પછી, તેના ફેરફારો કાયમી હોય છે અને સિસ્ટમ નિષ્ફળતા પછી પણ ટકી રહેશે.

SQLAlchemy ટ્રાન્ઝેક્શન્સનું સંચાલન કરવા માટેની પદ્ધતિઓ પ્રદાન કરે છે, જે આ ACID ગુણધર્મો જાળવી રાખે છે તેની ખાતરી કરે છે.

મૂળભૂત ટ્રાન્ઝેક્શન હેન્ડલિંગ

સૌથી સામાન્ય ટ્રાન્ઝેક્શન કામગીરીઓ કમિટ અને રોલબેક છે.

ટ્રાન્ઝેક્શન્સ કમિટ કરવું

જ્યારે ટ્રાન્ઝેક્શનની અંદરની તમામ કામગીરીઓ સફળતાપૂર્વક પૂર્ણ થઈ જાય, ત્યારે તમે ટ્રાન્ઝેક્શનને કમિટ કરો છો. આ ડેટાબેઝમાં ફેરફારોને સાચવે છે.

            try:
    # Add a new user
    new_user = User(name='Alice Smith', email='alice.smith@example.com')
    session.add(new_user)

    # Commit the transaction
    session.commit()
    print("Transaction committed successfully!")

except Exception as e:
    # Handle exceptions
    print(f"An error occurred: {e}")
    session.rollback()
    print("Transaction rolled back.")

finally:
    session.close()

            

              
                Copy
              
            
          

આ ઉદાહરણમાં:

• અમે સેશનમાં એક નવો `User` ઑબ્જેક્ટ ઉમેરીએ છીએ.
• અમે ડેટાબેઝમાં ફેરફારોને સાચવવા માટે `session.commit()` ને કૉલ કરીએ છીએ.
• સંભવિત અપવાદોને હેન્ડલ કરવા માટે અમે કોડને `try...except...finally` બ્લોકમાં લપેટીએ છીએ.
• જો કોઈ અપવાદ આવે, તો અમે ટ્રાન્ઝેક્શન દરમિયાન કરાયેલા કોઈપણ ફેરફારોને પૂર્વવત કરવા માટે `session.rollback()` ને કૉલ કરીએ છીએ.
• અમે સેશનને મુક્ત કરવા અને કનેક્શનને કનેક્શન પૂલ પર પાછા આપવા માટે `finally` બ્લોકમાં હંમેશા `session.close()` ને કૉલ કરીએ છીએ. આ રિસોર્સ લીક્સને ટાળવા માટે નિર્ણાયક છે. સેશન્સ બંધ કરવામાં નિષ્ફળતા કનેક્શન થાક અને એપ્લિકેશન અસ્થિરતા તરફ દોરી શકે છે.

ટ્રાન્ઝેક્શન્સ રોલ બેક કરવું

જો ટ્રાન્ઝેક્શન દરમિયાન કોઈ ભૂલ થાય, અથવા જો તમે નક્કી કરો કે ફેરફારો સાચવવા જોઈએ નહીં, તો તમે ટ્રાન્ઝેક્શનને રોલ બેક કરો છો. આ ડેટાબેઝને ટ્રાન્ઝેક્શન શરૂ થયું તે પહેલાંની તેની સ્થિતિમાં પાછો લાવે છે.

            try:
    # Add a user with an invalid email (example to force a rollback)
    invalid_user = User(name='Bob Johnson', email='invalid-email')
    session.add(invalid_user)

    # The commit will fail if the email is not validated on the database level
    session.commit()
    print("Transaction committed.")

except Exception as e:
    print(f"An error occurred: {e}")
    session.rollback()
    print("Transaction rolled back successfully.")

finally:
    session.close()

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, જો `invalid_user` ઉમેરવાથી કોઈ અપવાદ આવે (દા.ત., ડેટાબેઝ અવરોધના ઉલ્લંઘનને કારણે), તો `session.rollback()` કૉલ પ્રયાસિત દાખલને પૂર્વવત કરશે, ડેટાબેઝને યથાવત રાખશે.

અદ્યતન ટ્રાન્ઝેક્શન મેનેજમેન્ટ

ટ્રાન્ઝેક્શન સ્કોપિંગ માટે `with` સ્ટેટમેન્ટનો ઉપયોગ કરવો

ટ્રાન્ઝેક્શન્સનું સંચાલન કરવાની વધુ પાયથોનિક અને મજબૂત રીત `with` સ્ટેટમેન્ટનો ઉપયોગ કરવાની છે. આ સુનિશ્ચિત કરે છે કે સેશન યોગ્ય રીતે બંધ થાય છે, ભલે અપવાદો થાય.

            from contextlib import contextmanager

@contextmanager
def session_scope():
    """Provide a transactional scope around a series of operations."""
    session = Session()
    try:
        yield session
        session.commit()
    except Exception:
        session.rollback()
        raise
    finally:
        session.close()

# Usage:
with session_scope() as session:
    new_user = User(name='Charlie Brown', email='charlie.brown@example.com')
    session.add(new_user)
    # Operations within the 'with' block
    # If no exceptions occur, the transaction is committed automatically.
    # If an exception occurs, the transaction is rolled back automatically.
    print("User added.")

print("Transaction completed (committed or rolled back).")

            

              
                Copy
              
            
          

`session_scope` ફંક્શન એક કન્ટેક્સ્ટ મેનેજર છે. જ્યારે તમે `with` બ્લોકમાં પ્રવેશો છો, ત્યારે એક નવું સેશન બનાવવામાં આવે છે. જ્યારે તમે `with` બ્લોકમાંથી બહાર નીકળો છો, ત્યારે સેશન કાં તો કમિટ થાય છે (જો કોઈ અપવાદ ન થયા હોય તો) અથવા રોલ બેક થાય છે (જો કોઈ અપવાદ થયો હોય તો). સેશન હંમેશા `finally` બ્લોકમાં બંધ થાય છે.

નેસ્ટેડ ટ્રાન્ઝેક્શન્સ (સેવપોઇન્ટ્સ)

SQLAlchemy સેવપોઇન્ટ્સ નો ઉપયોગ કરીને નેસ્ટેડ ટ્રાન્ઝેક્શન્સને સપોર્ટ કરે છે. એક સેવપોઇન્ટ તમને સમગ્ર ટ્રાન્ઝેક્શનને અસર કર્યા વિના, મોટા ટ્રાન્ઝેક્શનની અંદરના ચોક્કસ બિંદુ પર રોલ બેક કરવાની મંજૂરી આપે છે.

            try:
    with session_scope() as session:
        user1 = User(name='David Lee', email='david.lee@example.com')
        session.add(user1)
        session.flush()  # Send changes to the database but don't commit yet

        # Create a savepoint
        savepoint = session.begin_nested()

        try:
            user2 = User(name='Eve Wilson', email='eve.wilson@example.com')
            session.add(user2)
            session.flush()

            # Simulate an error
            raise ValueError("Simulated error during nested transaction")

        except Exception as e:
            print(f"Nested transaction error: {e}")
            savepoint.rollback()
            print("Nested transaction rolled back to savepoint.")

        # Continue with the outer transaction, user1 will still be added
        user3 = User(name='Frank Miller', email='frank.miller@example.com')
        session.add(user3)

except Exception as e:
    print(f"Outer transaction error: {e}")


#Commit will commit user1 and user3, but not user2 due to the nested rollback

try:
    with session_scope() as session:
        #Verify only user1 and user3 exist
        users = session.query(User).all()
        for user in users:
            print(user)
except Exception as e:
    print(f"Unexpected Exception: {e}") #Should not happen

            

              
                Copy
              
            
          

આ ઉદાહરણમાં:

• અમે `session_scope()` નો ઉપયોગ કરીને એક આઉટર ટ્રાન્ઝેક્શન શરૂ કરીએ છીએ.
• અમે `user1` ને સેશનમાં ઉમેરીએ છીએ અને ફેરફારોને ડેટાબેઝમાં ફ્લશ કરીએ છીએ. `flush()` ફેરફારોને ડેટાબેઝ સર્વર પર મોકલે છે પરંતુ તેમને કમિટ કરતું *નથી*. તે તમને સમગ્ર ટ્રાન્ઝેક્શનને કમિટ કરતા પહેલા ફેરફારો માન્ય છે કે નહીં તે જોવાની મંજૂરી આપે છે (દા.ત., કોઈ અવરોધ ઉલ્લંઘન નથી).
• અમે `session.begin_nested()` નો ઉપયોગ કરીને એક સેવપોઇન્ટ બનાવીએ છીએ.
• નેસ્ટેડ ટ્રાન્ઝેક્શનની અંદર, અમે `user2` ઉમેરીએ છીએ અને ભૂલનું અનુકરણ કરીએ છીએ.
• અમે `savepoint.rollback()` નો ઉપયોગ કરીને નેસ્ટેડ ટ્રાન્ઝેક્શનને સેવપોઇન્ટ પર રોલ બેક કરીએ છીએ. આ ફક્ત નેસ્ટેડ ટ્રાન્ઝેક્શનમાં કરાયેલા ફેરફારોને પૂર્વવત કરે છે (એટલે કે, `user2` નો ઉમેરો).
• અમે આઉટર ટ્રાન્ઝેક્શન સાથે ચાલુ રાખીએ છીએ અને `user3` ઉમેરીએ છીએ.
• આઉટર ટ્રાન્ઝેક્શન કમિટ થાય છે, `user1` અને `user3` ને ડેટાબેઝમાં સાચવે છે, જ્યારે `user2` સેવપોઇન્ટ રોલબેકને કારણે કાઢી નાખવામાં આવે છે.

આઇસોલેશન સ્તરોને નિયંત્રિત કરવું

આઇસોલેશન સ્તરો એ ડિગ્રીને વ્યાખ્યાયિત કરે છે કે જેના દ્વારા સમકાલીન ટ્રાન્ઝેક્શન્સ એકબીજાથી અલગ હોય છે. ઉચ્ચ આઇસોલેશન સ્તરો વધુ ડેટા સુસંગતતા પ્રદાન કરે છે પરંતુ સમકાલીનતા અને પ્રદર્શન ઘટાડી શકે છે. SQLAlchemy તમને તમારા ટ્રાન્ઝેક્શન્સના આઇસોલેશન સ્તરને નિયંત્રિત કરવાની મંજૂરી આપે છે.

સામાન્ય આઇસોલેશન સ્તરોમાં શામેલ છે:

• રીડ અનકમિટ્ડ (Read Uncommitted): સૌથી નીચું આઇસોલેશન સ્તર. ટ્રાન્ઝેક્શન્સ અન્ય ટ્રાન્ઝેક્શન્સ દ્વારા કરાયેલા અનકમિટ્ડ ફેરફારો જોઈ શકે છે. આ ડર્ટી રીડ્સ તરફ દોરી શકે છે.
• રીડ કમિટ્ડ (Read Committed): ટ્રાન્ઝેક્શન્સ ફક્ત અન્ય ટ્રાન્ઝેક્શન્સ દ્વારા કરાયેલા કમિટ્ડ ફેરફારો જોઈ શકે છે. આ ડર્ટી રીડ્સને અટકાવે છે પરંતુ નોન-રિપીટેબલ રીડ્સ અને ફેન્ટમ રીડ્સ તરફ દોરી શકે છે.
• રિપીટેબલ રીડ (Repeatable Read): ટ્રાન્ઝેક્શન્સ સમગ્ર ટ્રાન્ઝેક્શન દરમિયાન સમાન ડેટા જોઈ શકે છે, ભલે અન્ય ટ્રાન્ઝેક્શન્સ તેમાં ફેરફાર કરે. આ ડર્ટી રીડ્સ અને નોન-રિપીટેબલ રીડ્સને અટકાવે છે પરંતુ ફેન્ટમ રીડ્સ તરફ દોરી શકે છે.
• સીરીયલાઈઝેબલ (Serializable): સૌથી ઉચ્ચ આઇસોલેશન સ્તર. ટ્રાન્ઝેક્શન્સ એકબીજાથી સંપૂર્ણપણે અલગ હોય છે. આ ડર્ટી રીડ્સ, નોન-રિપીટેબલ રીડ્સ અને ફેન્ટમ રીડ્સને અટકાવે છે પરંતુ સમકાલીનતાને નોંધપાત્ર રીતે ઘટાડી શકે છે.

ડિફૉલ્ટ આઇસોલેશન સ્તર ડેટાબેઝ સિસ્ટમ પર આધાર રાખે છે. તમે એન્જિન બનાવતી વખતે અથવા ટ્રાન્ઝેક્શન શરૂ કરતી વખતે આઇસોલેશન સ્તર સેટ કરી શકો છો.

ઉદાહરણ (PostgreSQL):

            from sqlalchemy.dialects.postgresql import dialect

# Set isolation level when creating the engine
engine = create_engine('postgresql://user:password@host:port/database',
                       connect_args={'options': '-c statement_timeout=1000'} #Example of timeout
                      )

# Set the isolation level when beginning a transaction (database specific)
# For postgresql, it's recommended to set it on the connection, not engine.

from sqlalchemy import event
from sqlalchemy.pool import Pool

@event.listens_for(Pool, "connect")
def set_isolation_level(dbapi_connection, connection_record):
    existing_autocommit = dbapi_connection.autocommit
    dbapi_connection.autocommit = True
    cursor = dbapi_connection.cursor()
    cursor.execute("SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE")
    dbapi_connection.autocommit = existing_autocommit
    cursor.close()


# Then transactions created via SQLAlchemy will use the configured isolation level.

            

              
                Copy
              
            
          

મહત્વપૂર્ણ: આઇસોલેશન સ્તરો સેટ કરવાની પદ્ધતિ ડેટાબેઝ-વિશિષ્ટ છે. સાચા સિન્ટેક્સ માટે તમારા ડેટાબેઝ ડોક્યુમેન્ટેશનનો સંદર્ભ લો. આઇસોલેશન સ્તરોને ખોટી રીતે સેટ કરવાથી અનપેક્ષિત વર્તન અથવા ભૂલો થઈ શકે છે.

સમકાલીનતા (Concurrency) હેન્ડલિંગ

જ્યારે બહુવિધ વપરાશકર્તાઓ અથવા પ્રક્રિયાઓ એક જ ડેટાને સમકાલીન રીતે ઍક્સેસ કરે છે, ત્યારે ડેટા ભ્રષ્ટાચારને અટકાવવા અને ડેટા સુસંગતતા સુનિશ્ચિત કરવા માટે સમકાલીનતાને યોગ્ય રીતે હેન્ડલ કરવું નિર્ણાયક છે. SQLAlchemy સમકાલીનતાને હેન્ડલ કરવા માટે ઘણી પદ્ધતિઓ પ્રદાન કરે છે, જેમાં ઑપ્ટિમિસ્ટિક લૉકિંગ અને પેસિમિસ્ટિક લૉકિંગ શામેલ છે.

ઑપ્ટિમિસ્ટિક લૉકિંગ

ઑપ્ટિમિસ્ટિક લૉકિંગ ધારે છે કે સંઘર્ષો દુર્લભ છે. તે ટ્રાન્ઝેક્શન કમિટ કરતા પહેલા અન્ય ટ્રાન્ઝેક્શન્સ દ્વારા કરાયેલા ફેરફારો માટે તપાસ કરે છે. જો કોઈ સંઘર્ષ મળી આવે, તો ટ્રાન્ઝેક્શન રોલ બેક થઈ જાય છે.

ઑપ્ટિમિસ્ટિક લૉકિંગને અમલમાં મૂકવા માટે, તમે સામાન્ય રીતે તમારા ટેબલમાં એક વર્ઝન કૉલમ ઉમેરો છો. જ્યારે પણ પંક્તિ અપડેટ થાય છે ત્યારે આ કૉલમ આપમેળે વધારવામાં આવે છે.

            from sqlalchemy import Column, Integer, String, Integer
from sqlalchemy.orm import declarative_base

Base = declarative_base()

class Article(Base):
    __tablename__ = 'articles'
    id = Column(Integer, primary_key=True)
    title = Column(String)
    content = Column(String)
    version = Column(Integer, nullable=False, default=1)

    def __repr__(self):
        return f"<Article(title='{self.title}', version='{self.version}')>"

#Inside of the try catch block

def update_article(session, article_id, new_content):
    article = session.query(Article).filter_by(id=article_id).first()

    if article is None:
        raise ValueError("Article not found")

    original_version = article.version

    # Update the content and increment the version
    article.content = new_content
    article.version += 1

    # Attempt to update, checking the version column in the WHERE clause
    rows_affected = session.query(Article).filter(
        Article.id == article_id,
        Article.version == original_version
    ).update({
        Article.content: new_content,
        Article.version: article.version
    }, synchronize_session=False)

    if rows_affected == 0:
        session.rollback()
        raise ValueError("Conflict: Article has been updated by another transaction.")
    
    session.commit()

            

              
                Copy
              
            
          

આ ઉદાહરણમાં:

• અમે `Article` મોડેલમાં `version` કૉલમ ઉમેરીએ છીએ.
• લેખને અપડેટ કરતા પહેલા, અમે વર્તમાન વર્ઝન નંબર સ્ટોર કરીએ છીએ.
• `UPDATE` સ્ટેટમેન્ટમાં, અમે એક `WHERE` ક્લોઝ શામેલ કરીએ છીએ જે તપાસે છે કે વર્ઝન કૉલમ હજુ પણ સ્ટોર કરેલા વર્ઝન નંબર બરાબર છે કે નહીં. `synchronize_session=False` SQLAlchemy ને અપડેટ કરેલા ઑબ્જેક્ટને ફરીથી લોડ કરતા અટકાવે છે; અમે સ્પષ્ટપણે વર્ઝનિંગને હેન્ડલ કરી રહ્યા છીએ.
• જો વર્ઝન કૉલમ અન્ય ટ્રાન્ઝેક્શન દ્વારા બદલવામાં આવ્યું હોય, તો `UPDATE` સ્ટેટમેન્ટ કોઈપણ પંક્તિઓને અસર કરશે નહીં (rows_affected 0 હશે), અને અમે એક અપવાદ ઊભો કરીએ છીએ.
• અમે ટ્રાન્ઝેક્શનને રોલ બેક કરીએ છીએ અને વપરાશકર્તાને જાણ કરીએ છીએ કે સંઘર્ષ થયો છે.

પેસિમિસ્ટિક લૉકિંગ

પેસિમિસ્ટિક લૉકિંગ ધારે છે કે સંઘર્ષો થવાની સંભાવના છે. તે પંક્તિ અથવા ટેબલને સંશોધિત કરતા પહેલા તેના પર લૉક મેળવે છે. આ અન્ય ટ્રાન્ઝેક્શન્સને લૉક રિલીઝ ન થાય ત્યાં સુધી ડેટાને સંશોધિત કરતા અટકાવે છે.

SQLAlchemy લૉક મેળવવા માટે ઘણા કાર્યો પ્રદાન કરે છે, જેમ કે `with_for_update()`.

            # Example using PostgreSQL
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base

# Database setup (replace with your actual database URL)
db_url = 'postgresql://user:password@host:port/database'
engine = create_engine(db_url, echo=False) #Set echo to true if you would like to see the SQL generated
Base = declarative_base()

class Item(Base):
    __tablename__ = 'items'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    value = Column(Integer)

    def __repr__(self):
        return f"<Item(name='{self.name}', value='{self.value}')>"

Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)

#Function to update the item (within a try/except)
def update_item_value(session, item_id, new_value):
    # Acquire a pessimistic lock on the item
    item = session.query(Item).filter(Item.id == item_id).with_for_update().first()

    if item is None:
        raise ValueError("Item not found")

    # Update the item's value
    item.value = new_value
    session.commit()
    return True

            

              
                Copy
              
            
          

આ ઉદાહરણમાં:

• અમે `with_for_update()` નો ઉપયોગ કરીને `Item` પંક્તિને અપડેટ કરતા પહેલા તેના પર લૉક મેળવીએ છીએ. આ અન્ય ટ્રાન્ઝેક્શન્સને વર્તમાન ટ્રાન્ઝેક્શન કમિટ ન થાય અથવા રોલ બેક ન થાય ત્યાં સુધી પંક્તિને સંશોધિત કરતા અટકાવે છે. `with_for_update()` ફંક્શન ડેટાબેઝ-વિશિષ્ટ છે; વિગતો માટે તમારા ડેટાબેઝ ડોક્યુમેન્ટેશનનો સંપર્ક કરો. કેટલાક ડેટાબેઝમાં અલગ લૉકિંગ પદ્ધતિઓ અથવા સિન્ટેક્સ હોઈ શકે છે.

મહત્વપૂર્ણ: પેસિમિસ્ટિક લૉકિંગ સમકાલીનતા અને પ્રદર્શન ઘટાડી શકે છે, તેથી તેનો ઉપયોગ ફક્ત ત્યારે જ કરો જ્યારે જરૂરી હોય.

અપવાદ હેન્ડલિંગ શ્રેષ્ઠ પ્રથાઓ

ડેટા અખંડિતતા સુનિશ્ચિત કરવા અને એપ્લિકેશન ક્રેશને અટકાવવા માટે યોગ્ય અપવાદ હેન્ડલિંગ નિર્ણાયક છે. હંમેશા તમારી ડેટાબેઝ કામગીરીઓને `try...except` બ્લોક્સમાં લપેટી અને અપવાદોને યોગ્ય રીતે હેન્ડલ કરો.

અહીં અપવાદ હેન્ડલિંગ માટે કેટલીક શ્રેષ્ઠ પ્રથાઓ છે:

• વિશિષ્ટ અપવાદોને પકડવું: `Exception` જેવા સામાન્ય અપવાદોને પકડવાનું ટાળો. વિવિધ પ્રકારની ભૂલોને અલગ રીતે હેન્ડલ કરવા માટે `sqlalchemy.exc.IntegrityError` અથવા `sqlalchemy.exc.OperationalError` જેવા વિશિષ્ટ અપવાદોને પકડો.
• ટ્રાન્ઝેક્શન્સને રોલ બેક કરવું: જો કોઈ અપવાદ આવે તો હંમેશા ટ્રાન્ઝેક્શનને રોલ બેક કરો.
• અપવાદોને લૉગ કરવું: સમસ્યાઓનું નિદાન અને નિરાકરણ કરવામાં મદદ કરવા માટે અપવાદોને લૉગ કરો. તમારા લોગ્સમાં શક્ય તેટલો વધુ સંદર્ભ શામેલ કરો (દા.ત., વપરાશકર્તા ID, ઇનપુટ ડેટા, ટાઇમસ્ટેમ્પ).
• યોગ્ય હોય ત્યારે અપવાદોને ફરીથી ઊભા કરવા: જો તમે અપવાદને હેન્ડલ કરી શકતા નથી, તો તેને ઉચ્ચ-સ્તરના હેન્ડલરને તેની સાથે વ્યવહાર કરવાની મંજૂરી આપવા માટે તેને ફરીથી ઊભો કરો.
• સંસાધનો સાફ કરવા: હંમેશા સેશન બંધ કરો અને `finally` બ્લોકમાં અન્ય કોઈપણ સંસાધનોને મુક્ત કરો.

            import logging
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base
from sqlalchemy.exc import IntegrityError, OperationalError

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Database setup (replace with your actual database URL)
db_url = 'postgresql://user:password@host:port/database'
engine = create_engine(db_url, echo=False)
Base = declarative_base()

class Product(Base):
    __tablename__ = 'products'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    price = Column(Integer)

    def __repr__(self):
        return f"<Product(name='{self.name}', price='{self.price}')>"

Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)

# Function to add a product
def add_product(session, name, price):
    try:
        new_product = Product(name=name, price=price)
        session.add(new_product)
        session.commit()
        logging.info(f"Product '{name}' added successfully.")
        return True
    except IntegrityError as e:
        session.rollback()
        logging.error(f"IntegrityError: {e}")
        #Handle database constraint violations (e.g., duplicate name)
        return False
    except OperationalError as e:
        session.rollback()
        logging.error(f"OperationalError: {e}")
        #Handle connection errors or other operational issues
        return False
    except Exception as e:
        session.rollback()
        logging.exception(f"An unexpected error occurred: {e}")
        # Handle any other unexpected errors
        return False
    finally:
        session.close()

            

              
                Copy
              
            
          

આ ઉદાહરણમાં:

• અમે પ્રક્રિયા દરમિયાન ઇવેન્ટ્સ રેકોર્ડ કરવા માટે લૉગિંગને ગોઠવીએ છીએ.
• અમે `IntegrityError` (અવરોધ ઉલ્લંઘન માટે) અને `OperationalError` (કનેક્શન ભૂલો માટે) જેવા વિશિષ્ટ અપવાદોને પકડીએ છીએ.
• અમે `except` બ્લોક્સમાં ટ્રાન્ઝેક્શનને રોલ બેક કરીએ છીએ.
• અમે `logging` મોડ્યુલનો ઉપયોગ કરીને અપવાદોને લૉગ કરીએ છીએ. `logging.exception()` પદ્ધતિ લોગ સંદેશમાં સ્ટેક ટ્રેસને આપમેળે શામેલ કરે છે.
• જો આપણે તેને હેન્ડલ ન કરી શકીએ તો અમે અપવાદને ફરીથી ઊભો કરીએ છીએ.
• અમે `finally` બ્લોકમાં સેશન બંધ કરીએ છીએ.

ડેટાબેઝ કનેક્શન પૂલિંગ

SQLAlchemy ડેટાબેઝ કનેક્શન્સને કાર્યક્ષમ રીતે સંચાલિત કરવા માટે કનેક્શન પૂલિંગનો ઉપયોગ કરે છે. એક કનેક્શન પૂલ ડેટાબેઝ સાથે ખુલ્લા કનેક્શન્સનો સમૂહ જાળવે છે, જે એપ્લિકેશન્સને દરેક વિનંતી માટે નવા કનેક્શન્સ બનાવવાની જગ્યાએ હાલના કનેક્શન્સનો ફરીથી ઉપયોગ કરવાની મંજૂરી આપે છે. આ પ્રદર્શનમાં નોંધપાત્ર સુધારો કરી શકે છે, ખાસ કરીને એવી એપ્લિકેશન્સમાં જે મોટી સંખ્યામાં સમકાલીન વિનંતીઓને હેન્ડલ કરે છે.

SQLAlchemy નું `create_engine()` ફંક્શન આપમેળે કનેક્શન પૂલ બનાવે છે. તમે `create_engine()` માં આર્ગ્યુમેન્ટ્સ પસાર કરીને કનેક્શન પૂલને ગોઠવી શકો છો.

સામાન્ય કનેક્શન પૂલ પેરામીટરમાં શામેલ છે:

• pool_size: પૂલમાં કનેક્શન્સની મહત્તમ સંખ્યા.
• max_overflow: pool_size ઉપરાંત બનાવી શકાય તેવા કનેક્શન્સની સંખ્યા.
• pool_recycle: જે પછી કનેક્શનને રિસાયકલ કરવામાં આવે છે તે સેકન્ડ્સની સંખ્યા.
• pool_timeout: કનેક્શન ઉપલબ્ધ થાય તેની રાહ જોવાનો સેકન્ડ્સનો સમય.

            engine = create_engine('postgresql://user:password@host:port/database',
                       pool_size=5, #Maximum pool size
                       max_overflow=10, #Maximum overflow
                       pool_recycle=3600, #Recycle connections after 1 hour
                       pool_timeout=30
                      )

            

              
                Copy
              
            
          

મહત્વપૂર્ણ: તમારી એપ્લિકેશનની જરૂરિયાતો અને તમારા ડેટાબેઝ સર્વરની ક્ષમતાઓના આધારે યોગ્ય કનેક્શન પૂલ સેટિંગ્સ પસંદ કરો. ખોટી રીતે ગોઠવેલો કનેક્શન પૂલ પ્રદર્શન સમસ્યાઓ અથવા કનેક્શન થાક તરફ દોરી શકે છે.

અસુમેળ ટ્રાન્ઝેક્શન્સ (Async SQLAlchemy)

ઉચ્ચ સમકાલીનતાની જરૂરિયાત ધરાવતી આધુનિક એપ્લિકેશન્સ માટે, ખાસ કરીને FastAPI અથવા AsyncIO જેવા અસુમેળ ફ્રેમવર્ક સાથે બનેલી એપ્લિકેશન્સ માટે, SQLAlchemy Async SQLAlchemy નામનું અસુમેળ સંસ્કરણ પ્રદાન કરે છે.

Async SQLAlchemy મુખ્ય SQLAlchemy ઘટકોના અસુમેળ સંસ્કરણો પ્રદાન કરે છે, જે તમને ઇવેન્ટ લૂપને અવરોધિત કર્યા વિના ડેટાબેઝ કામગીરી કરવા દે છે. આ તમારી એપ્લિકેશન્સના પ્રદર્શન અને સ્કેલેબિલિટીમાં નોંધપાત્ર સુધારો કરી શકે છે.

અહીં Async SQLAlchemy નો ઉપયોગ કરવાનું એક મૂળભૂત ઉદાહરણ છે:

            from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import declarative_base
from sqlalchemy import Column, Integer, String
import asyncio

# Database setup (replace with your actual database URL)
db_url = 'postgresql+asyncpg://user:password@host:port/database'
engine = create_async_engine(db_url, echo=False)
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String)

    def __repr__(self):
        return f"<User(name='{self.name}', email='{self.email}')>"

async def create_db_and_tables():
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)


async def add_user(name, email):
    async with AsyncSession(engine) as session:
        new_user = User(name=name, email=email)
        session.add(new_user)
        await session.commit()

async def main():
    await create_db_and_tables()
    await add_user("Async User", "async.user@example.com")

if __name__ == "__main__":
    asyncio.run(main())

            

              
                Copy
              
            
          

સમકાલીન SQLAlchemy થી મુખ્ય તફાવતો:

• `create_engine` ને બદલે `create_async_engine` નો ઉપયોગ થાય છે.
• `Session` ને બદલે `AsyncSession` નો ઉપયોગ થાય છે.
• તમામ ડેટાબેઝ કામગીરીઓ અસુમેળ હોય છે અને તેને `await` નો ઉપયોગ કરીને પ્રતીક્ષા કરવી આવશ્યક છે.
• અસુમેળ ડેટાબેઝ ડ્રાઇવરો (દા.ત., PostgreSQL માટે `asyncpg`) નો ઉપયોગ કરવો આવશ્યક છે.

મહત્વપૂર્ણ: Async SQLAlchemy ને ડેટાબેઝ ડ્રાઇવરની જરૂર છે જે અસુમેળ કામગીરીને સપોર્ટ કરે છે. ખાતરી કરો કે તમારી પાસે સાચો ડ્રાઇવર ઇન્સ્ટોલ કરેલો અને ગોઠવેલો છે.

નિષ્કર્ષ

ડેટાબેઝ સાથે ક્રિયાપ્રતિક્રિયા કરતી મજબૂત અને વિશ્વસનીય પાયથોન એપ્લિકેશન્સ બનાવવા માટે SQLAlchemy સેશન અને ટ્રાન્ઝેક્શન મેનેજમેન્ટમાં નિપુણતા મેળવવી આવશ્યક છે. સેશન્સ, ટ્રાન્ઝેક્શન્સ, આઇસોલેશન સ્તરો અને સમકાલીનતાની વિભાવનાઓને સમજીને, અને અપવાદ હેન્ડલિંગ અને કનેક્શન પૂલિંગ માટે શ્રેષ્ઠ પ્રથાઓનું પાલન કરીને, તમે ડેટા અખંડિતતા સુનિશ્ચિત કરી શકો છો અને તમારી એપ્લિકેશન્સના પ્રદર્શનને ઑપ્ટિમાઇઝ કરી શકો છો.

ભલે તમે એક નાની વેબ એપ્લિકેશન અથવા મોટા પાયે એન્ટરપ્રાઇઝ સિસ્ટમ બનાવી રહ્યા હોવ, SQLAlchemy તમને તમારા ડેટાબેઝની ક્રિયાપ્રતિક્રિયાઓને અસરકારક રીતે સંચાલિત કરવા માટે જરૂરી સાધનો પ્રદાન કરે છે. તમારી એપ્લિકેશન્સની વિશ્વસનીયતા સુનિશ્ચિત કરવા માટે હંમેશા ડેટા અખંડિતતાને પ્રાધાન્ય આપવાનું અને સંભવિત ભૂલોને ગ્રેસફુલ્લી હેન્ડલ કરવાનું યાદ રાખો.

અદ્યતન વિષયોનું અન્વેષણ કરવાનું વિચારો જેમ કે:

• ટુ-ફેઝ કમિટ (2PC): બહુવિધ ડેટાબેઝમાં ફેલાયેલા ટ્રાન્ઝેક્શન્સ માટે.
• શાર્ડિંગ (Sharding): બહુવિધ ડેટાબેઝ સર્વર્સમાં ડેટાનું વિતરણ કરવા માટે.
• ડેટાબેઝ સ્થળાંતર (Database migrations): ડેટાબેઝ સ્કીમા ફેરફારોનું સંચાલન કરવા માટે Alembic જેવા સાધનોનો ઉપયોગ કરવો.